#include <iostream>
#include <windows.h>
#include <conio.h>
#include "Const.h"
#include "Field.h"
#include "Food.h"
#include "Snake.h"
#include "Game.h"
#include "winconsole.h"


//��������������� ��������� �������� ���������� ����.
void init_game(char** field, int& columns, int& rows, int * snake_x, int* snake_y, DIRECTION& direction, int& snake_size, int& timeout, int& game_on, int& score)//��������������� ��������� �������� ���������� ����.
{	
	srand(time(0));//��������� ������ ������������������, ������������ �������� rand() 	

	system("cls");//������ ������� �������

	init_snake(snake_x, snake_y, snake_size, columns, rows);//������������� ������� �������� ��������� ������ (snake_size � �������)
	
	//start_snake(snake_x, snake_y, snake_size, columns, rows);//������� ���������� ���������� ��������� ������ ������ 

	init_field(field, columns, rows);//�������������  ���� (������� ���������� ���� � ������)

	set_snake(field, snake_x, snake_y, snake_size);//������ ��������������� � ������� ����

	print_field(field, columns, rows, score);//������ ����

	std::cout << "Press any key" << std::endl;//5)	����� ����������� � ����.
}

//������ ��������������� � ������� ����
void set_snake(char** field, int* snake_x, int* snake_y, int& snake_size)
{	
		field[snake_y[0]][snake_x[0]] = head_symbol;//��������� ������

		// ��������� ������, ���� ����
		
		for (int i = 1; i < snake_size; i++)
		{			
			field[snake_y[i]][snake_x[i]] = tail_symbol;
		}	

		if (snake_size == 2) { field[0][0] = border_symbol; }
}

//��������� ������� ������ � �������
void clear_snake(char** field, int* snake_x, int* snake_y, int& snake_size)
{
	//������ "�����"
	field[snake_y[snake_size-1]][snake_x[snake_size-1]] = field_symbol;
}

// ��� ��������������� � ������� ����.
void set_food(char** field, int& columns, int& rows, int& snake_size, bool& food_flag, int& food_x, int& food_y)
{
	if (!food_flag && snake_size < L)//���� ��� ��� � ������ �� �������� ������������� �������
	{
		do
		{
			generate_food(food_x, food_y, columns, rows);

		} while (field[food_y][food_x] != field_symbol);

		field[food_y][food_x] = food_symbol;

		food_flag = true;
	}	
}

//����������� �������� ����, ��� ������ ����� ���.
void check_eating(int* snake_x, int* snake_y, int& food_y , int& food_x, int& snake_size, bool& food_flag, int& score)
{
	if (snake_y[0] == food_y && snake_x[0] == food_x)//������� ���
	{
		food_flag = false;//��� ���
		++score;
		snake_size++; //���������� ������� ������		
	}

}




//����������� �������� ����, ��� ������ ����������� � �������
void check_snake(char** field, int* snake_x, int* snake_y, int& game_on)
{
	if (field[snake_y[0]][snake_x[0]] == tail_symbol) //������ ����������� � �������
	{
		game_on = 0;
	}

}

//�������� ����������  ����.
int check_game(char** field, int* snake_x, int* snake_y, int& snake_size, bool& food_flag, int& game_on)
{
	int tmp_game_on = game_on;

	if (!food_flag && snake_size == L)//���� ��� ��� � ������ ������������� �������
	{		
		tmp_game_on = 0;
	}
		
	check_snake(field, snake_x, snake_y, tmp_game_on); //�������� ����, ��� ������ ����������� � �������
	
	return tmp_game_on;
}

//��������� ����������������� �����
void handle_cmd(DIRECTION& direction, int& game_on)
{
	char key;//	��� ����� ���� ������� � ����������
	char keep_direct;//	��� ���������� �������  ����������� ��������.
	DIRECTION tmp_direction;

		key = _getch();
		
		if (key == 0 || key == -32)
		{
			keep_direct = _getch();
						
			switch (keep_direct)
			{
			case up: {tmp_direction = turn_up; } break;
			case down: {tmp_direction = turn_down; } break;
			case left: {tmp_direction = turn_left; } break;
			case right: {tmp_direction = turn_right; } break;
			
			default: {tmp_direction = err; }
			}
		}
		else
		{
			switch (key = toupper(key))
			{
			case 'D': {tmp_direction = turn_right; } break;
			case 'A': {tmp_direction = turn_left; } break;
			case 'W': {tmp_direction = turn_up; } break;
			case 'S': {tmp_direction = turn_down; } break;
			case '0': {game_on = 0; } return;
			case esc: {game_on = 0; } return;
				break;
			default: {tmp_direction = err; }
			}
		}
		if (tmp_direction != err)
		{
			switch (direction)
			{
			case turn_up:
			{
				if (tmp_direction == turn_down) { direction = turn_up; }
				else { direction = tmp_direction; }
			} break;
			case turn_down:
			{
				if (tmp_direction == turn_up) { direction = turn_down; }
				else { direction = tmp_direction; }
			} break;
			case turn_left:
			{
				if (tmp_direction == turn_right) { direction = turn_left; }
				else { direction = tmp_direction; }
			} break;
			case turn_right:
			{
				if (tmp_direction == turn_left) { direction = turn_right; }
				else { direction = tmp_direction; }
			} break;
			}
		}
}


// ����� ���������� ��� ��������� ����
void game_over(char** field, int& columns, int& rows, int* snake_x, int* snake_y, int& score)
{
	setCursorPosition(0, 0);

	field[snake_y[0]][snake_x[0]] = head_symbol;

	print_field(field, columns, rows, score);

	std::cout << "The end!" << std::endl;

	//������ ������
	for (int i = 0; i < rows; i++)
	{
		delete[] field[i];
	}

	delete[] field;

}